package com.snapan.controller;

import com.snapan.entity.User;
import com.snapan.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 用户表控制器
 */
@RestController
@RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 获取列表
     */
    @GetMapping("/list")
    public Map<String, Object> getList() {
        Map<String, Object> result = new HashMap<>();
        try {
            List<User> list = userService.getAll();
            result.put("success", true);
            result.put("data", list);
            result.put("message", "获取列表成功");
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "获取列表失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 根据ID获取
     */
    @GetMapping("/{id}")
    public Map<String, Object> getById(@PathVariable Long id) {
        Map<String, Object> result = new HashMap<>();
        try {
            User user = userService.getById(id);
            if (user != null) {
                result.put("success", true);
                result.put("data", user);
                result.put("message", "获取成功");
            } else {
                result.put("success", false);
                result.put("message", "数据不存在");
            }
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "获取失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 添加
     */
    @PostMapping("/add")
    public Map<String, Object> add(@RequestBody User user) {
        Map<String, Object> result = new HashMap<>();
        try {
            boolean success = userService.add(user);
            result.put("success", success);
            result.put("message", success ? "添加成功" : "添加失败");
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "添加失败：" + e.getMessage());
        }
        return result;
    }


    /**
     * 更新用户信息 - 支持部分字段更新
     * @return 更新后的用户信息
     */
    @PutMapping(value = "/info", produces = "application/json;charset=UTF-8")
    @ResponseBody
    public Integer updateUser(@RequestParam(required = false) String username,
                                             @RequestParam(required = false) String avatar,
                                             @RequestParam Long id) {

            Integer rows = userService.update(username,avatar,id);
          return rows;
    }

    /**
     * 删除
     */
    @DeleteMapping("/{id}")
    public Map<String, Object> delete(@PathVariable Long id) {
        Map<String, Object> result = new HashMap<>();
        try {
            boolean success = userService.delete(id);
            result.put("success", success);
            result.put("message", success ? "删除成功" : "删除失败");
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "删除失败：" + e.getMessage());
        }
        return result;
    }

    /**
     * 查询用户存储使用情况（已用/总空间，单位：字节）
     */
    @GetMapping("/{id}/storage")
    public Map<String, Object> getStorage(@PathVariable Long id) {
        Map<String, Object> result = new HashMap<>();
        try {
            Long used = userService.getUsedSpace(id);
            Long total = userService.getTotalSpace(id);
            Map<String, Object> data = new HashMap<>();
            data.put("used", used);
            data.put("total", total);
            result.put("success", true);
            result.put("data", data);
        } catch (Exception e) {
            result.put("success", false);
            result.put("message", "查询存储失败：" + e.getMessage());
        }
        return result;
    }

    @PostMapping("/login")
    @ResponseBody
    public Map<String, Object> login(
            @RequestParam String email,
            @RequestParam String password,
            HttpSession session) {

        Map<String, Object> result = new HashMap<>();
        // 调用Service层查询用户
        User user = userService.selectByEmailAndPassword(email, password);

        if (user != null) {
            // 登录成功：存入Session，返回成功标识（不做后端跳转）
            session.setAttribute("loginUser", user);
            result.put("success", true);
            result.put("message", "登录成功");
        } else {
            // 登录失败：返回失败信息
            result.put("success", false);
            result.put("message", "邮箱或密码错误");
        }
        return result; // 返回JSON给前端，由前端决定跳转
    }

    /**
     * 处理退出登录
     * @param session 销毁Session，清除登录状态
     * @return 重定向到登录页
     */
    @GetMapping("/user/logout")
    public String logout(HttpSession session) {
        session.invalidate(); // 销毁Session
        return "/login";
    }

    /**
     * 检查用户是否登录的接口
     * 前端调用此接口判断是否需要跳转登录页
     */
    @GetMapping("/check-login")
    @ResponseBody // 确保返回JSON格式
    public Map<String, Object> checkLoginStatus(HttpSession session) {
        Map<String, Object> result = new HashMap<>();

        // 从Session中获取登录用户（登录成功时存入的"loginUser"）
        User loginUser = (User) session.getAttribute("loginUser");

        if (loginUser != null) {
            // 已登录：返回登录状态+用户基本信息（DTO）
            User userDTO = new User();
            userDTO.setId(loginUser.getId());
            userDTO.setEmail(loginUser.getEmail());
            userDTO.setNickname(loginUser.getNickname()); // 假设User实体有nickname字段

            result.put("loggedIn", true);  // 登录状态：已登录
            result.put("user", userDTO);   // 用户信息（非敏感）
        } else {
            // 未登录：返回未登录状态
            result.put("loggedIn", false); // 登录状态：未登录
            result.put("user", null);
        }

        return result;
    }
    /**
     * 从Session中获取当前登录用户信息（示例接口）
     * 用于前端需要展示用户信息的场景（如顶部导航显示用户名）
     */
    @GetMapping("/current-user")
    @ResponseBody
    public Map<String, Object> getCurrentUser(HttpSession session) {
        Map<String, Object> result = new HashMap<>();

        User loginUser = (User) session.getAttribute("loginUser");

        if (loginUser != null) {
            User userDTO = new User();
            userDTO.setId(loginUser.getId());
            userDTO.setEmail(loginUser.getEmail());
            userDTO.setNickname(loginUser.getNickname());

            result.put("success", true);
            result.put("data", userDTO);
        } else {
            result.put("success", false);
            result.put("message", "用户未登录");
        }

        return result;
    }



    /**
     * 检查邮箱是否已存在
     * @param email 邮箱地址
     * @return 检查结果
     */
    @GetMapping("/check-email")
    public ResponseEntity<?> checkEmailExists(@RequestParam String email) {
        try {
            if (email == null || email.trim().isEmpty()) {
                return ResponseEntity.badRequest().body(createErrorResponse("邮箱参数不能为空"));
            }

            boolean exists = userService.existsByEmail(email);
            Map<String, Object> result = new HashMap<>();
            result.put("email", email);
            result.put("exists", exists);
            result.put("message", exists ? "邮箱已被注册" : "邮箱可用");

            return ResponseEntity.ok(createSuccessResponse("检查完成", result));
        } catch (Exception e) {
            return ResponseEntity.internalServerError().body(createErrorResponse("检查失败：" + e.getMessage()));
        }
    }

    /**
     * 用户注册接口
     */
    @PostMapping("/register")
    public ResponseEntity<?> register(
            @RequestParam String email,
            @RequestParam String username,
            @RequestParam String password,
            @RequestParam(required = false) String nickname,
            @RequestParam(required = false) String avatar) {

        try {
            // 1. 基本参数验证（非空校验）
            if (email == null || email.trim().isEmpty()) {
                return ResponseEntity.badRequest().body(createErrorResponse("邮箱不能为空"));
            }
            if (username == null || username.trim().isEmpty()) {
                return ResponseEntity.badRequest().body(createErrorResponse("用户名不能为空"));
            }
            if (password == null || password.trim().isEmpty()) {
                return ResponseEntity.badRequest().body(createErrorResponse("密码不能为空"));
            }

            // 2. 验证邮箱是否已注册
            if (userService.existsByEmail(email)) {
                return ResponseEntity.badRequest().body(createErrorResponse("该邮箱已被注册，请更换邮箱"));
            }

            // 3. 构建用户对象并设置属性
            User user = new User();
            user.setEmail(email.trim()); // 去除空格
            user.setUsername(username.trim());
            user.setPassword(password); // 注意：实际生产环境需在此处加密密码（如BCrypt）
            // 昵称默认使用用户名（若未传入）
            user.setNickname(nickname != null && !nickname.trim().isEmpty() ? nickname.trim() : username.trim());
            user.setAvatar(avatar); // 头像可为空（使用默认头像）

            // 4. 设置默认值（与业务规则匹配）
            user.setTotalSpace(5L * 1024 * 1024 * 1024); // 默认5GB存储空间
            user.setUsedSpace(0L); // 初始已用空间为0
            user.setStatus((byte) 1); // 默认为正常状态（1-正常，0-禁用）
            user.setIsAdmin((byte) 0); // 默认为普通用户（0-非管理员）
            user.setJoinTime(new Date()); // 注册时间为当前时间

            // 5. 调用Service层执行注册（返回影响行数）
            Integer affectedRows = userService.register(user);

            // 6. 根据影响行数判断注册结果
            if (affectedRows != null && affectedRows > 0) {
                // 注册成功：返回用户信息（不含敏感字段）
                Map<String, Object> userInfo = new HashMap<>();
                userInfo.put("id", user.getId()); // MyBatis已通过useGeneratedKeys回填id
                userInfo.put("username", user.getUsername());
                userInfo.put("email", user.getEmail());
                userInfo.put("nickname", user.getNickname());
                userInfo.put("avatar", user.getAvatar());
                userInfo.put("totalSpace", user.getTotalSpace());
                userInfo.put("usedSpace", user.getUsedSpace());
                userInfo.put("joinTime", user.getJoinTime());

                return ResponseEntity.ok(createSuccessResponse("注册成功", userInfo));
            } else {
                // 注册失败：影响行数为0或null
                return ResponseEntity.badRequest().body(createErrorResponse("注册失败，请重试"));
            }

        } catch (Exception e) {
            // 捕获异常（如数据库异常）
            return ResponseEntity.internalServerError()
                    .body(createErrorResponse("服务器异常：" + e.getMessage()));
        }
    }
    @PostMapping("/update-password")
    public ResponseEntity<String> updatePassword( @RequestParam String email, @RequestParam String newPassword) {
        // 调用服务层执行修改
        userService.updatePasswordByEmail(email, newPassword);
        return ResponseEntity.ok("密码修改成功，请使用新密码登录");
    }



    /**
     * 统一成功响应格式
     */
    private Map<String, Object> createSuccessResponse(String message, Object data) {
        Map<String, Object> response = new HashMap<>();
        response.put("success", true);
        response.put("code", 200);
        response.put("message", message);
        response.put("data", data);
        response.put("timestamp", System.currentTimeMillis());
        return response;
    }

    /**
     * 统一错误响应格式
     */
    private Map<String, Object> createErrorResponse(String message) {
        Map<String, Object> response = new HashMap<>();
        response.put("success", false);
        response.put("code", 400);
        response.put("message", message);
        response.put("timestamp", System.currentTimeMillis());
        return response;
    }





}




















